import express from 'express';
const router = express.Router();
import axios from 'axios';
import _ from 'lodash';
import mongoose from 'mongoose';
import { DEEPSEEK_API_KEY } from '../config.js';
import Question from '../models/Question.js';
import { initDB, addQuestions, getQuestions, clearQuestions } from '../utils/dbService.js';

// const localQuestionBank = require('../localQuestionBank');

// 初始化数据库
initDB().catch(err => console.error('数据库初始化失败:', err));

// 生成题库(支持临时题库模式)
router.post('/generate', async (req, res) => {
  const { gameType, caseTypes, previousQuestions = [], useTempBank = true } = req.body;
  
  // 检查是否有可用的临时题库
  if (useTempBank) {
    const currentQuestions = await getQuestions();
    if (currentQuestions.length >= 5) {
      // 返回前5道题并从题库中移除
      const questionsToReturn = currentQuestions.slice(0, 5);
      await clearQuestions();
      return res.json({ 
        questions: questionsToReturn,
        fromTempBank: true,
        status: 'ok'
      });
    }
  }
  try {
    const { gameType, caseTypes, previousQuestions = [] } = req.body;
    
    if (!gameType || !caseTypes || !Array.isArray(caseTypes)) {
      return res.status(400).json({ error: '参数无效' });
    }
    
    console.log('生成题库，案例类型:', caseTypes);
    console.log('游戏类型:', gameType);
    
    // 检查API密钥
    if (!DEEPSEEK_API_KEY || DEEPSEEK_API_KEY === '在这里填入你的DeepSeek API Key') {
      console.error('DeepSeek API密钥未配置');
      // API密钥未配置时直接使用本地题库
      return res.json({ 
        questions: await getLocalQuestions(caseTypes),
        warning: 'API未配置，使用本地题库',
        status: 'ok' 
      });
    }

    // 构建提示词
    const prompt = `请严格按照以下格式出5道民法单选题，题目限于${caseTypes.join('、')}，要求难度适中且贴近生活，适合普法使用：\n\n
题1：[题目内容]\nA. [选项A]\nB. [选项B]\nC. [选项C]\nD. [选项D]\n答案：[正确答案]\n解析：[详细解析]\n
题2：[题目内容]\nA. [选项A]\nB. [选项B]\nC. [选项C]\nD. [选项D]\n答案：[正确答案]\n解析：[详细解析]\n
题3：[题目内容]\nA. [选项A]\nB. [选项B]\nC. [选项C]\nD. [选项D]\n答案：[正确答案]\n解析：[详细解析]\n
题4：[题目内容]\nA. [选项A]\nB. [选项B]\nC. [选项C]\nD. [选项D]\n答案：[正确答案]\n解析：[详细解析]\n
题5：[题目内容]\nA. [选项A]\nB. [选项B]\nC. [选项C]\nD. [选项D]\n答案：[正确答案]\n解析：[详细解析]\n\n重要提示：\n1. 每道题必须包含题号、题目、四个选项（A-D）、答案和解析\n2. 答案只写选项字母（如：A）\n3. 解析内容请放在一行内\n4. 不要使用Markdown格式\n5. 题目内容应多样化，涵盖不同法律场景\n6. 解析部分需包含：相关法律条文（注明具体条款）\n7. 每次生成的题目必须与历史题目不同，不得重复或高度相似，题干、选项和解析内容都要有明显差异，避免模板化和重复。请参考以往未出现过的生活场景，确保题目新颖有创意。`;

    // 如果有之前的题目，添加到提示词中以避免重复
    let enhancedPrompt = prompt;
    if (previousQuestions && previousQuestions.length > 0) {
      // 题目量可能很大，只取最近的20道题目避免提示词过长
      const recentQuestions = previousQuestions.slice(-20);
      
      enhancedPrompt += "\n\n严格禁止重复或类似以下任何历史题目，一定要生成全新的题目：\n";
      
      recentQuestions.forEach((q, index) => {
        if (q && q.question) {
          enhancedPrompt += `${index + 1}. "${q.question.substring(0, 100)}"\n`;
        }
      });
      
      enhancedPrompt += "\n非常重要：以上题目绝对禁止重复或改写，请确保生成的5道题目与上述历史题目有明显差异，题干不得相似，情景、案例类型和法律要点需要完全不同。";
      enhancedPrompt += "\n请设计全新的生活场景、全新的案例，确保题目新颖有创意，与历史题目毫无关联。";
      
      console.log(`增强提示词：添加了${recentQuestions.length}个历史题目作为避免重复的参考`);
    }

    // 打印最终使用的提示词长度和部分内容
    console.log(`最终提示词长度: ${enhancedPrompt.length} 字符，前300字符: ${enhancedPrompt.substring(0, 300)}...`);
    console.log(`提示词中包含的历史题目数量: ${previousQuestions ? previousQuestions.length : 0}`);

    // 增加随机性，避免生成相似题目
    const temperature = 0.9;  // 提高随机性
    const randomNumber = Math.floor(Math.random() * 1000);  // 添加随机数作为种子

    // 调用API生成新题目
    try {
      console.log(`开始调用API生成题目，temperature=${temperature}, 随机种子=${randomNumber}`);
      
      const response = await axios({
        method: 'post',
        url: 'https://api.deepseek.com/v1/chat/completions',
        headers: {
          'Authorization': `Bearer ${DEEPSEEK_API_KEY}`,
          'Content-Type': 'application/json'
        },
        data: {
          model: 'deepseek-chat',
          messages: [
            { role: 'system', content: `你是一个法律题库出题专家，需要设计不同于历史题库的全新题目。当前时间戳: ${Date.now()}, 随机种子: ${randomNumber}` },
            { role: 'user', content: enhancedPrompt }
          ],
          max_tokens: 2000,
          temperature: temperature,
          timeout: 60000
        }
      });

      if (!response.data || !response.data.choices || !response.data.choices[0] || !response.data.choices[0].message) {
        throw new Error('API返回数据格式不正确');
      }

      const content = response.data.choices[0].message.content;
      console.log('API返回内容:', content);

      // 解析题目
      let questions = await parseQuestions(content);
      
      // 如果题目数量不足5道，使用本地题库
      if (questions.length < 5) {
        console.log(`只解析出${questions.length}道题，使用本地题库补充`);
        const localQuestions = (await getLocalQuestions(caseTypes)).slice(0, 5 - questions.length);
        questions = questions.concat(localQuestions);
      }

      // 确保返回5道题
      const finalQuestions = questions.slice(0, 5);
      
      // 转换题目格式以匹配模型
      const formattedQuestions = finalQuestions.map((q, index) => {
        // 将答案字母转换为选项索引 (A=0, B=1, etc.)
        let correctAnswer = q.answer ? q.answer.charCodeAt(0) - 65 : 0;
        // 确保correctAnswer在有效范围内
        if (correctAnswer < 0 || correctAnswer > 3) {
          console.warn(`无效的答案索引: ${correctAnswer}, 重置为0`);
          correctAnswer = 0;
        }
        // 按顺序分配案例类型，确保多样性
        const caseType = caseTypes[index % caseTypes.length];
        
        return {
          question: q.question,
          options: q.options,
          correctAnswer,
          explanation: q.explanation,
          caseType,
          answer: String.fromCharCode(65 + correctAnswer), // 保留原始答案文本
          createdAt: new Date()
        };
      });

      try {
        // 存入临时题库
        await clearQuestions();
        await addQuestions(formattedQuestions);
        
        // 存入MongoDB备份
        await Question.insertMany({
          caseTypes,
          questions: formattedQuestions,
          createdAt: new Date()
        });
        console.log(`成功存入${formattedQuestions.length}道题目到临时题库和数据库`);
      } catch (dbError) {
        console.error('题目存储失败:', dbError.message);
        throw dbError;
      }

      // 返回前5道题
      const questionsToReturn = formattedQuestions.splice(0, 5);
      res.json({ 
        questions: questionsToReturn,
        remaining: formattedQuestions.length,
        status: 'ok'
      });

    } catch (apiError) {
      console.error('DeepSeek API调用失败:', apiError.message);
      // API调用失败时使用本地题库
      return res.json({ 
        questions: await getLocalQuestions(caseTypes),
        warning: 'API调用失败，使用本地题库',
        status: 'ok' 
      });
    }
  } catch (error) {
    console.error('生成题库失败:', error);
      return res.json({ 
        questions: await getLocalQuestions(caseTypes),
        warning: '服务器错误，使用本地题库',
        status: 'ok' 
      });
  }
});

// 解析API返回的题目
async function parseQuestions(content) {
  // 清理Markdown格式
  const cleanedContent = content.replace(/\*\*/g, '');
  const questions = [];

  // 分割题目块（支持"题1："或"题1:等"）
  const questionBlocks = cleanedContent.split(/题\d+[：:]/).filter(block => block.trim());

  for (const block of questionBlocks) {
    try {
      // 题干
      const questionMatch = block.match(/^(.+?)\n/);
      const question = questionMatch ? questionMatch[1].trim().replace(/\n/g, ' ') : '';

      // 选项（支持一行或多行）
      let options = [];
      // 先找一行内的所有选项
      const optionsLineMatch = block.match(/A[.．、:：][^\nA-D]*[\s\S]*?B[.．、:：][^\nA-D]*[\s\S]*?C[.．、:：][^\nA-D]*[\s\S]*?D[.．、:：][^\n答案\n]*/);
      if (optionsLineMatch) {
        // 拆分A~D
        const optStr = optionsLineMatch[0];
        const optMatches = optStr.match(/([A-D][.．、:：][^A-D\n]+)/g);
        if (optMatches && optMatches.length === 4) {
          options = optMatches.map(s => s.replace(/^[A-D][.．、:：]/, '').trim());
        }
      }
      // 如果没找到一行内的4个选项，再尝试逐行找
      if (options.length !== 4) {
        options = [];
        for (let i = 0; i < 4; i++) {
          const letter = String.fromCharCode(65 + i);
          const reg = new RegExp(`${letter}[.．、:：]\s*([^\n]+)`);
          const m = block.match(reg);
          options.push(m ? m[1].trim() : '');
        }
      }

      // 答案
      let answer = '';
      const answerMatch = block.match(/答案[：:][\s\n]*([A-D])/);
      if (answerMatch) answer = answerMatch[1].trim().toUpperCase();

      // 解析
      let explanation = '';
      const explanationMatch = block.match(/解析[：:][ \t]*([^\n]+)/);
      if (explanationMatch) explanation = explanationMatch[1].trim();
      // 若解析内容在多行，尝试合并
      if (explanationMatch) {
        const after = block.split(explanationMatch[0])[1];
        if (after) {
          const nextLine = after.split('\n')[0].trim();
          if (nextLine && !/^题\d+[：:]/.test(nextLine) && !/^[A-D][.．、:：]/.test(nextLine)) {
            explanation += ' ' + nextLine;
          }
        }
      }

      // 校验
      if (question && options.length === 4 && options.every(o => o) && answer && explanation) {
        questions.push({ question, options, answer, explanation });
      } else {
        console.log('题目解析结果不完整:', { question, options, answer, explanation });
      }
    } catch (error) {
      console.error('解析题目块失败:', error);
    }
  }

  // 如果没有成功解析任何题目，使用本地题库
  if (questions.length === 0) {
    console.log('未能解析出有效题目，将使用本地题库');
    return await getLocalQuestions(['知识产权纠纷', '婚姻家庭与继承纠纷']);
  }

  return questions;
}

// 从本地题库获取题目（按类型筛选并使用lodash洗牌算法）
async function getLocalQuestions(caseTypes, previousQuestions = []) {
  let allQuestions = [];
  for (const type of caseTypes) {
    try {
      const questionsForType = (await import(`../questionBank/${type}.cjs`)).default;
      // 过滤掉已出过的题目
      const filteredQuestions = questionsForType.filter(q => 
        !previousQuestions.some(pq => pq.question === q.question)
      );
      allQuestions = allQuestions.concat(filteredQuestions);
    } catch (error) {
      console.warn(`无法加载 '${type}' 类型的题库文件: ${error.message}`);
    }
  }
  
  // 使用lodash洗牌算法确保更好的随机性
  const shuffledQuestions = _.shuffle(allQuestions);
  
  // 如果过滤后题目不足，尝试从历史题库获取
  if (shuffledQuestions.length < 5) {
    console.log('本地题库题目不足，尝试从数据库获取历史题目');
    return getQuestionsFromDB(caseTypes, previousQuestions);
  }
  
  return shuffledQuestions.slice(0, 5);
}

// 从数据库获取历史题目
// 维护一个全局的已出题索引
const questionIndexMap = new Map();

// 移除未使用的tempQuestionBank变量

async function getQuestionsFromDB(caseTypes, previousQuestions = []) {
  try {
    const cachedQuestions = await Question.find({ 
      caseTypes: { $in: caseTypes },
      createdAt: { $gte: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000) } // 30天内
    })
    .sort({ createdAt: -1 }) // 按时间倒序
    .limit(50)
    .exec();

    // 初始化索引
    const cacheKey = caseTypes.join(',');
    if (!questionIndexMap.has(cacheKey)) {
      questionIndexMap.set(cacheKey, 0);
    }

    // 过滤已出题目
    const filtered = cachedQuestions.filter(q => 
      !previousQuestions.some(pq => pq.question === q.question)
    );

    // 顺序取题
    const startIdx = questionIndexMap.get(cacheKey);
    const questions = [];
    for (let i = 0; i < 5 && i < filtered.length; i++) {
      const idx = (startIdx + i) % filtered.length;
      questions.push(filtered[idx]);
    }
    
    // 更新索引
    questionIndexMap.set(cacheKey, (startIdx + 5) % filtered.length);
    
    return questions;
  } catch (error) {
    console.error('从数据库获取题目失败:', error);
    return [];
  }
}

export default router;
